1. Field of the Invention
The present invention generally relates to the following system modely=Hs+w,  (1)where y is an Nr×1 complex received signal vector, H is an Nr×Nt complex channel matrix, s is an Nt×1 complex transmitted signal vector drawn from the QAM constellation set, whose real and imaginary parts are {−+1, . . . , −1, 1, . . . , −1} with  being the constellation size, and w is the additive white Gaussian noise vector with zero mean and covariance matrix as σw2INr. In the most general case, the invention is an improved complex lattice reduction (LR) technique used in the LR-aided detectors to find the near-optimal solution to (1).
2. Description of Related Art
Multi-input multi-output (MIMO) systems have been adopted in recent wireless standards (e.g., IEEE 802.11n/ac, 3GPP LTE/LTE-A) because of the high spectral efficiency and large coverage. The system model (1) can be applied to multi-input multi-output (MIMO) system, generalized signal carrier frequency division multiple access (GSC-FDMA) system, and precoded FDMA (P-FDMA) system as special cases, with different realizations of the H matrix corresponding to different systems. To recover the signal vector s given the model (1), different detection methods can be adopted. The optimal detection is the maximum likelihood (ML) detector, but it exhibits exponential complexity. To alleviate the complexity of the ML detector, linear detectors (LDs), successive interference cancelation (SIC) detector, and K-best detector, have been proposed. However, these detectors degrade error performance due to diversity loss. To obtain high error performance with low complexity in the detection of problem (1), lattice reduction (LR) techniques have been added to the existing LDs, SIC, and K-best detectors to collect full receive diversity.
LLL/ELLL Algorithm
Among different LR schemes, LLL/ELLL algorithm is a commonly adopted technique in LR-aided detectors. The detailed complex LLL algorithm based on QR preprocessing (the preprocessing part can also be sorted QR decomposition (SQRD) or MISE-SQRD to reduce LLL's complexity) can be found in Table I. The LLL/ELLL iteratively performs three steps: 1) size reduction for LLL or effective size reduction for ELLL (lines 4-10); 2) Lovász condition evaluation (line 11); and 3) column swap (lines 12-15) if the Lovász condition is not satisfied. The ½<δ≦1 used in the LLL/ELLL is a quality parameter selected to control the performance-complexity tradeoff (larger δ leads to better performance with higher complexity). Note that during the execution of the LLL/ELLL algorithm, the column swap may not happen in some cases, which is not efficient in terms of convergence and complexity.
TABLE ITHE LLL/ELLL ALGORITHMInput: Q, R, P (after QR/SQRD/MMSE-SQRD†)Output: Q, R, T 1: Initialization: Q = Q, R = R, T = P, δ ∈ (1/2, 1] 2: k = 2 3: while k < Nt  4:    5:  6:    7:  8:    9: 10:                                                                        for                ⁢                                                                  ⁢                n                            =                                                                    k                    -                    1                                    :                                                            -                      1                                        :                                          1                      ⁢                                              (                        LLL                        )                                            ⁢                                                                                          ⁢                      or                      ⁢                                                                                          ⁢                      for                      ⁢                                                                                          ⁢                      n                                                                      =                                  k                  -                                      1                    ⁢                                          (                      ELLL                      )                                                                                                                                                                                          ⁢                              u                =                                  ⌈                                                                                    R                        ~                                                                    n                        ,                        k                                                              /                                                                  R                        ~                                                                    n                        ,                        n                                                                              ⌉                                                                                                                                                    ⁢                                                if                  ⁢                                                                          ⁢                  u                                ≠                0                                                                                                                                    ⁢                                                R                  ~                                ⁢                                  =                                                            1                      :                      n                                        ,                    k                                                  ⁢                                  =                                                                                    R                        ~                                                                                              1                          :                          n                                                ,                        k                                                              -                                          u                      ⁢                                                                        R                          ~                                                                                                      1                            :                            n                                                    ,                          n                                                                                                                                                                                                                                        ⁢                                                T                                      :                                          ,                      k                                                                      =                                                      T                                          :                                              ,                        k                                                                              -                                      uT                                          :                                              ,                        n                                                                                                                                                                                                                ⁢              end                                                            end                              }             ⁢                                          (            effective            )                    ⁢                                          ⁢          size                                    reduction             11:if δ|Rk−1, k−1|2 > |Rk,k|2+|Rk−1, k|2}Lovasz condition 12:       13:       14:   15:                                                                                                    ⁢                                                swap                  ⁢                                                                          ⁢                  columns                  ⁢                                                                          ⁢                  k                                -                                  1                  ⁢                                                                          ⁢                  and                  ⁢                                                                          ⁢                  k                  ⁢                                                                          ⁢                  in                  ⁢                                                                          ⁢                                      R                    ~                                    ⁢                                                                          ⁢                  and                  ⁢                                                                          ⁢                                      T                    ~                                                                                                                                                                      ⁢                              Θ                =                                                      [                                                                                                                        α                            *                                                                                                    β                                                                                                                                                  -                            β                                                                                                    α                                                                                      ]                                    ⁢                                                                          ⁢                  with                  ⁢                                                                          ⁢                                                                                                              α                          =                                                                                                                    R                                ~                                                                                                                              k                                  -                                  1                                                                ,                                                                  k                                  -                                  1                                                                                                                                                                                                                                                    R                                  ~                                                                                                                                                                            k                                      -                                      1                                                                        :                                    k                                                                    ,                                                                      k                                    -                                    1                                                                                                                                                                                                                                                                                                                                                  β                          =                                                                                                                    R                                ~                                                                                            k                                ,                                                                  k                                  -                                  1                                                                                                                                                                                                                                                    R                                  ~                                                                                                                                                                            k                                      -                                      1                                                                        :                                    k                                                                    ,                                                                      k                                    -                                    1                                                                                                                                                                                                                                                                                                                                                                                                                            ⁢                                                                    R                    ~                                                                                                      k                        -                        1                                            :                      k                                        ,                                                                  k                        -                        1                                            :                                              N                        t                                                                                            =                                  Θ                  ⁢                                                            R                      ~                                                                                                                k                          -                          1                                                :                        k                                            ,                                                                        k                          -                          1                                                :                                                  N                          t                                                                                                                                                                                                                                        ⁢                                                                    Q                    ~                                                        :                                          ,                                                                        k                          -                          1                                                :                        k                                                                                            =                                                                            Q                      ~                                                              :                                              ,                                                                              k                            -                            1                                                    :                          k                                                                                                      ⁢                                      Θ                    ℋ                                                                                          }             ⁢  column  ⁢          ⁢  swap 16:  k=max(k−1,2)17: else18:  k = k + 119: end20:end†QR: H = QR, P = I;SQRD: HP = QR;MMSE-SQRD: HP = [QT{circumflex over (Q)}T]TR.Q is an Nr × Nt matrix, R and P are Nt × Nt matrixes.Existing Greedy LLL Algorithms
The existing greedy LLL algorithms, i.e., possible-swap LLL with optimal swap selection criterion (PSLLL-OSSC) and greedy diagonal reduction (GDR), add two major modifications to the original LLL algorithm before each LLL iteration: one is to find the candidate set of LLL iterations with column swap operations; the other is to select an LLL iteration in the candidate set such that the decrease of LLL potential is maximized each time. These modifications make the column swap always happen during the execution of the greedy LLL algorithms. Therefore, the existing greedy LLL algorithms converge faster and/or exhibit lower complexity than the original LLL/ELLL algorithm.